Graphical modelization of applications using, for instance Unified Modeling Language (UML) is a complete part of the development process for modern applications. Most applications today are described at a higher level of abstractions in UML, for example through class diagrams, and then derived in actual code. UML is commonly used to conduct design reviews early in the process of software development. One example of typical applications with user interface is a Web application which provides the actual presentation of a user interface with Web pages and the control of user interaction flows. In the Web application there is an interaction between the user with the databases and other kinds of system services, through standard Internet technologies, including Web browsers and HTTP which is all about user interfaces.
However, user interfaces today are not well taken into account with the standard UML processes, although they represent a significant piece of the software to develop and thus need to go through the same design reviews as the rest of the other components.
The US patent application US20060004845 assigned to Microsoft corporation proposes to automate the production of the user-interface of an application by defining a set of maps that will be applied to the UML class diagram and used to generate the actual UI.
The maps described here are external to the UML model. So the User Interface is not a part of the model itself but some additional process, that involves external, non-UML descriptions are involved in order to produce the user interface code.
Thus it is not possible with US20060004845 to design at a high level the user interface along with the system and manipulate both of them in the same representation, namely UML.
There is thus a need in today's application design to represent user interfaces in UML and have these user interface artifacts to connect gracefully with the other artifacts rather than be disruptive and involve a completely separate definition. With this goal achieved, a user can expect to obtain the same benefits from the user-interface artifacts as they get from the other artifacts of their software thanks to UML representations.
The first document “UML Model Mappings for Platform Independent User Interface Design” by Tim Schattkowsky1 and Marc Lohmann2 presented at the MODELS 2005 Workshops (http://wwwcs.uni-paderborn.de/cs/ag-engels/Papers/2006/ModelMappingsforPlatformIndependentInterfaceDesign-LNCS-Version.pdf) describes transformations from logical model to user-interface dedicated models. Several transformations are involved from the original logical model in order to describe in details the composition of the user-interface. Although this first document provides a platform independent way to define user-interfaces, the process to do it ends up with several models. The first logical one does not contain any information about user-interface and the next levels contain detailed information about the UI Elements that are then able to be transformed into widgets. This design does not provide a simple, single representation at a high level of abstraction of the user interface and its connection to the logical model. It also involves detailed user-interface constructs.
A second document “A UML Profile for GUI Layout” from the Master's Thesis of Kai Blankenhorn dated May 23, 2004, (http://www.bitfolge.de/pubs/thesis/Thesis_GUILayout.pdf) provides a set of profiles to describe in details user-interface components in UML. This approach does not provide a way to represent User Interface components at a high level of abstraction which complements the logical model. The representation here is extremely detailed and does not allow an easy connection with the logical model.
Describing the full graphical contents of a user interface in UML is not satisfactory as 1/ there is a lot of work involved in describing the interface, that can be more easily done in a UI composer 2/ the stereotypes provided are not generic. They represent widgets of a given framework (e.g. Java SWING, JSF, etc.).
Mapping UML classes to Domain Specific language does not either provide a way to represent the user interface in UML.
There is thus a need for a tool that would extend the current UML representations and support user interface, describe the user interface at an equivalent level of abstraction as the other artifacts, connect them with the other UML classes. These descriptions would be handled in UML, in a similar fashion as any other class, using the standard UML diagrams.